#lang racket

(require scheme/foreign)
(unsafe!)

(provide machine-type print-machine-type read-sms-raw read-sms-real read-sms-scaled make-motion motion-x motion-y motion-z)


; le type de retour
(define-struct motion (x y z))

; je bind la librairie dynamique C libUniMotion.dylib
(define maLib (ffi-lib "libUniMotion"))

; le type de machine
(define machine-type
  (get-ffi-obj "detect_sms" maLib (_fun -> _int)))

; retourne le type de la machine
(define (print-machine-type)
  (let ((type (get-ffi-obj "detect_sms" maLib (_fun -> _int))))
    (cond ((= (type) 0) 'unknown)
          ((= (type) 1) 'powerbook)
          ((= (type) 2) 'ibook)
          ((= (type) 3) 'highrespb)
          ((= (type) 4) 'macbookpro)
          (else (error "machine non reconnue")))))

; prend le type de machine en paramètre
; et retourne les valeurs brute de l'acceleromètre
; sous forme de struct motion
; ex: (read-sms-raw (machine-type)) -> struct(x y z)
(define read-sms-raw
  (get-ffi-obj "read_sms_raw" maLib (_fun _int
                                          (x : (_ptr o _int))
                                          (y : (_ptr o _int))
                                          (z : (_ptr o _int))
                                          -> _int
                                          -> (values (make-motion x y z))
                                          )))

; comme read-sms-real sauf que
; x y z sont des réels
; néanmoins il faudra utiliser l'outil de calibrage
; si on compte utiliser cette fonction
(define read-sms-real
  (get-ffi-obj "read_sms_real" maLib (_fun _int
                                           (x : (_ptr o _int))
                                           (y : (_ptr o _int))
                                           (z : (_ptr o _int))
                                           -> _int
                                           -> (values (make-motion x y z))
                                           )))

; comme read-sms-scaled sauf que x y z sont des entiers scalé
(define read-sms-scaled
  (get-ffi-obj "read_sms_scaled" maLib (_fun _int
                                           (x : (_ptr o _int))
                                           (y : (_ptr o _int))
                                           (z : (_ptr o _int))
                                           -> _int
                                           -> (values (make-motion x y z))
                                           )))







